home *** CD-ROM | disk | FTP | other *** search
/ ftp.mactech.com 2010 / ftp.mactech.com.tar / ftp.mactech.com / thinkref / archive / THINKPascalUH2.1.sea / THINKPas Univ Hdr 2.1 / Interfaces / OCEStandardDirectory.p < prev    next >
Text File  |  1995-09-14  |  19KB  |  613 lines
  1. { Converted with MPW2TPas Tuesday, September 12, 1995 8:35:11 PM }
  2. {}
  3. {     File:        OCEStandardDirectory.p}
  4. { }
  5. {     Contains:    Apple Open Collaboration Environment Standard Directory Interfaces.}
  6. { }
  7. {     Version:    Technology:    AOCE Toolbox 1.02}
  8. {                 Package:    Universal Interfaces 2.1 in “MPW Latest” on ETO #18}
  9. { }
  10. {     Copyright:    © 1984-1995 by Apple Computer, Inc.}
  11. {                 All rights reserved.}
  12. { }
  13. {     Bugs?:        If you find a problem with this file, use the Apple Bug Reporter}
  14. {                 stack.  Include the file and version information (from above)}
  15. {                 in the problem description and send to:}
  16. {                     Internet:    apple.bugs@applelink.apple.com}
  17. {                     AppleLink:    APPLE.BUGS}
  18. { }
  19. {}
  20.  
  21. unit OCEStandardDirectory;
  22. interface
  23.  
  24.  
  25. {$IFC UNDEFINED __OCESTANDARDDIRECTORY__}
  26. {$SETC __OCESTANDARDDIRECTORY__ := 1}
  27.  
  28.     uses
  29.         ConditionalMacros, Types, AppleTalk, Processes, PPCToolbox, Notification, EPPC, Files, Aliases, AppleEvents, Icons, Quickdraw, Controls, Windows, OCE, OCEAuthDir;
  30.  
  31. { $PUSH}
  32. { $ALIGN MAC68K}
  33. { $LibExport+}
  34.  
  35.     const
  36.         gestaltSDPStandardDirectoryVersion = 'sdvr';
  37.         gestaltSDPFindVersion = 'dfnd';
  38.         gestaltSDPPromptVersion = 'prpv';
  39.  
  40.         genericDirectoryIconResource = -16721;                        { icl8, icl4, ICN#, ics#, ics4, ics8, sicn  }
  41.         genericLockedDirectoryIconResource = -16716;                { icl8, icl4, ICN#, ics#, ics4, ics8, sicn  }
  42.         genericRecordIconResource = -16722;                        { icl8, icl4, ICN#, ics#, ics4, ics8, sicn  }
  43.         genericAttributeIconResource = -16723;                        { icl8, icl4, ICN#, ics#, ics4, ics8, sicn  }
  44.         genericTemplateIconResource = -16746;                        { icl8, icl4, ICN#, ics#, ics4, ics8 }
  45.  
  46. { standard icon suites }
  47.         directoryFolderIconResource = -16720;                        { icl8, icl4, ICN#, ics#, ics4, ics8, sicn  }
  48.         lockedDirectoryFolderIconResource = -16719;                    { icl8, icl4, ICN#, ics#, ics4, ics8, sicn  }
  49.         personalDirectoryIconResource = -16718;                        { icl8, icl4, ICN#, ics#, ics4, ics8, sicn  }
  50.         directoriesIconResource = -16717;                        { icl8, icl4, ICN#, ics#, ics4, ics8, sicn  }
  51.         preferredPersonalDirectoryIconResource = -16724;            { icl8, icl4, ICN#, ics#, ics4, ics8, sicn  }
  52.  
  53. { icon IDs for spinning arrows }
  54.         kFirstSpinnerIcon = -16745;
  55.         kLastSpinnerIcon = -16738;
  56.  
  57. { resource types }
  58.         kSDPPanelResourceType = 'panl';
  59.         kSDPFindPanelResourceType = 'find';
  60.  
  61. { Standard FindPanel resource }
  62.         kStandardFindLayout = -16700;
  63.  
  64. { Prompt For Identity structures }
  65.         kSDPGuestBit = 0;
  66.         kSDPSpecificIdentityBit = 1;
  67.         kSDPLocalIdentityBit = 2;
  68.  
  69. { Values of SDPIdentityKind }
  70.         kSDPGuestMask = $1;
  71.         kSDPSpecificIdentityMask = $2;
  72.         kSDPLocalIdentityMask = $4;
  73.  
  74.  
  75.     type
  76.         SDPIdentityKind = INTEGER;
  77.  
  78.  
  79.     const
  80.         kSDPSuggestionOnly = 0;
  81.         kSDPRestrictToDirectory = 1;
  82.         kSDPRestrictToRecord = 2;
  83.  
  84.  
  85.     type
  86.         SDPLoginFilterKind = INTEGER;
  87.  
  88. { Panel Structures }
  89. {}
  90. {While the panel is in operation, four selection states may exist.}
  91. {    1) kSDPNothingSelected means nothing is selected.}
  92. {    2) kContainSelected means a volume, folder, catalog, dnode, or PAB is selected.}
  93. {    3) kSDPLockedContainerSelected means one of the above, but no access privledges.}
  94. {    4) kSDPRecordSelected means that a record is currently selected.}
  95. {}
  96. { Values of SDPSelectionState }
  97.  
  98.     const
  99.         kSDPNothingSelected = 0;
  100.         kSDPLockedContainerSelected = 1;
  101.         kSDPContainerSelected = 2;
  102.         kSDPRecordSelected = 3;
  103.         kSDPRecordAliasSelected = 4;
  104.         kSDPContainerAliasSelected = 5;
  105.  
  106.  
  107.     type
  108.         SDPSelectionState = INTEGER;
  109.  
  110. {}
  111. {This type informs the caller of the action the user took, either as the result}
  112. {of an event (as returned by SDPPanelEvent) or when SDPOpenSelectedItem is called.}
  113. {}
  114. {kSDPProcessed means that the event (or call to SDPOpenSelectedItem) resulted in no}
  115. {state change.}
  116. {}
  117. {kSDPSelectedAnItem indicates that the user wants to select the currently-hilited}
  118. {record. This is returned, for example, when a user double-clicks on a record.}
  119. {}
  120. {kSDPChangedSelection implies that the user clicked on a new item (which may mean}
  121. {that no item is selected).}
  122. {}
  123. { Values of SDPPanelState }
  124.  
  125.     const
  126.         kSDPProcessed = 0;
  127.         kSDPSelectedAnItem = 1;
  128.         kSDPChangedSelection = 2;
  129.  
  130.  
  131.     type
  132.         SDPPanelState = INTEGER;
  133.  
  134. {}
  135. {Your application may read any of the fields in a SDPPanelRecord, but it should}
  136. {use the appropriate routines to make changes to the records with the exception}
  137. {of the refCon field which your application may read or write at will.  Private}
  138. {information follows the SDPPanelRecord, so the handle must not be re-sized.}
  139. {}
  140.         SDPPanelRecord = record
  141.                 bounds: Rect;
  142.                 visible: BOOLEAN;
  143.                 enabled: BOOLEAN;
  144.                 focused: BOOLEAN;
  145.                 padByte: SInt8; { Byte }
  146.                 identity: AuthIdentity;
  147.                 refCon: LONGINT;
  148.                 listRect: Rect;
  149.                 popupRect: Rect;
  150.                 numberOfRows: INTEGER;
  151.                 rowHeight: INTEGER;
  152.                 pabMode: BOOLEAN;
  153.                 filler1: BOOLEAN;
  154.             end;
  155.  
  156.         SDPPanelPtr = ^SDPPanelRecord;
  157.         SDPPanelHandle = ^SDPPanelPtr;
  158.  
  159.         PanelBusyProcPtr = ProcPtr;  { PROCEDURE PanelBusy(Panel: SDPPanelHandle; busy: BOOLEAN); }
  160.         PanelBusyUPP = UniversalProcPtr;
  161.  
  162.     const
  163.         uppPanelBusyProcInfo = $000001C0; { PROCEDURE (4 byte param, 1 byte param); }
  164.  
  165.     function NewPanelBusyProc (userRoutine: PanelBusyProcPtr): PanelBusyUPP;
  166.     {$IFC NOT GENERATINGCFM }
  167.     inline
  168.         $2E9F;
  169.     {$ENDC}
  170.  
  171.     procedure CallPanelBusyProc (Panel: SDPPanelHandle; busy: BOOLEAN; userRoutine: PanelBusyUPP);
  172.     {$IFC NOT GENERATINGCFM}
  173.     inline
  174.         $205F, $4E90;
  175.     {$ENDC}
  176.  
  177.     type
  178.         PanelBusyProc = PanelBusyUPP;
  179.  
  180. { Find Panel Structures }
  181.  
  182.     const
  183.         kSDPItemIsSelectedBit = 0;
  184.         kSDPFindTextExistsBit = 1;
  185.  
  186. { Values of SDPFindPanelState }
  187.         kSDPItemIsSelectedMask = $1;
  188.         kSDPFindTextExistsMask = $2;
  189.  
  190.  
  191.     type
  192.         SDPFindPanelState = INTEGER;
  193.  
  194. { Values of SDPFindPanelFocus }
  195.  
  196.     const
  197.         kSDPFindPanelNoFocus = 0;
  198.         kSDPFindPanelListHasFocus = 1;
  199.         kSDPFindPanelTextHasFocus = 2;
  200.  
  201.  
  202.     type
  203.         SDPFindPanelFocus = INTEGER;
  204.  
  205.         SDPFindPanelRecord = record
  206.                 upperLeft: Point;
  207.                 visible: BOOLEAN;
  208.                 enabled: BOOLEAN;
  209.                 nowFinding: BOOLEAN;
  210.                 padByte: SInt8; { Byte }
  211.                 currentFocus: SDPFindPanelFocus;
  212.                 identity: AuthIdentity;
  213.                 simultaneousSearchCount: INTEGER;
  214.                 refCon: LONGINT;
  215.             end;
  216.  
  217.         SDPFindPanelPtr = ^SDPFindPanelRecord;
  218.         SDPFindPanelHandle = ^SDPFindPanelPtr;
  219.  
  220. { Values of SDPFindPanelResult }
  221.  
  222.     const
  223.         kSDPSelectedAFindItem = 0;
  224.         kSDPFindSelectionChanged = 1;
  225.         kSDPFindCompleted = 2;
  226.         kSDPTextStateChanged = 3;
  227.         kSDPFocusChanged = 4;
  228.         kSDPSelectionAndFocusChanged = 5;
  229.         kSDPMenuChanged = 6;
  230.         kSDPSelectionAndMenuChanged = 7;
  231.         kSDPProcessedFind = 8;
  232.  
  233.  
  234.     type
  235.         SDPFindPanelResult = INTEGER;
  236.  
  237.         PackedRStringListHandle = ^PackedPathNamePtr;
  238.  
  239.         PackedDSSpecHandle = ^PackedDSSpecPtr;
  240.  
  241.         FindPanelBusyProcPtr = ProcPtr;  { PROCEDURE FindPanelBusy(findPanel: SDPFindPanelHandle; busy: BOOLEAN); }
  242.         FindPanelBusyUPP = UniversalProcPtr;
  243.  
  244.     const
  245.         uppFindPanelBusyProcInfo = $000001C0; { PROCEDURE (4 byte param, 1 byte param); }
  246.  
  247.     function NewFindPanelBusyProc (userRoutine: FindPanelBusyProcPtr): FindPanelBusyUPP;
  248.     {$IFC NOT GENERATINGCFM }
  249.     inline
  250.         $2E9F;
  251.     {$ENDC}
  252.  
  253.     procedure CallFindPanelBusyProc (findPanel: SDPFindPanelHandle; busy: BOOLEAN; userRoutine: FindPanelBusyUPP);
  254.     {$IFC NOT GENERATINGCFM}
  255.     inline
  256.         $205F, $4E90;
  257.     {$ENDC}
  258.  
  259.     type
  260.         FindPanelBusyProc = FindPanelBusyUPP;
  261.  
  262. { Prompt For Identity Routines }
  263.  
  264.     function SDPPromptForID (var id: AuthIdentity; guestPrompt: ConstStr255Param; specificIDPrompt: ConstStr255Param; localIDPrompt: ConstStr255Param; {CONST}
  265.                                     var recordType: RString; permittedKinds: SDPIdentityKind; var selectedKind: SDPIdentityKind; {CONST}
  266.                                     var loginFilter: RecordID; filterKind: SDPLoginFilterKind): OSErr;
  267.     {$IFC NOT GENERATINGCFM}
  268.     inline
  269.         $203C, 16, 904, $AA5D;
  270.     {$ENDC}
  271. {}
  272. {SDPNewPanel creates a new panel. You supply the window in which the panel}
  273. {is to live, the bounds for the panel (which includes both the menu and the list),}
  274. {whether or not the panel is to be initially visible, the initial RLI (nil for}
  275. {catalogs and volumes), the types of records that will be shown (only a single}
  276. {(non-nil) type which may contain wildcards), the identity by which to browse}
  277. {(for access control reasons), and a refCon which is  available to the caller.}
  278. {}
  279.     function SDPNewPanel (var newPanel: SDPPanelHandle; window: WindowPtr; {CONST}
  280.                                     var bounds: Rect; visible: BOOLEAN; enabled: BOOLEAN; {CONST}
  281.                                     var initialRLI: PackedRLI; {CONST}
  282.                                     var typesList: RStringPtr; typeCount: LONGINT; identity: AuthIdentity; enumFlags: DirEnumChoices; matchTypeHow: ByteParameter; refCon: LONGINT): OSErr;
  283.     {$IFC NOT GENERATINGCFM}
  284.     inline
  285.         $203C, 21, 100, $AA5D;
  286.     {$ENDC}
  287. {}
  288. {SDPSetIdentity Sets the identity used for browsing.  NOTE: This call is likely to go}
  289. {away if the new authentication scheme works.}
  290. {}
  291.     function SDPSetIdentity (panel: SDPPanelHandle; identity: AuthIdentity): OSErr;
  292.     {$IFC NOT GENERATINGCFM}
  293.     inline
  294.         $203C, 4, 115, $AA5D;
  295.     {$ENDC}
  296. {}
  297. {SDPGetNewPanel is similar to SDPNewPanel above, except it takes a resource id of a}
  298. {'panl' resource.}
  299. {}
  300.     function SDPGetNewPanel (var newPanel: SDPPanelHandle; resourceID: INTEGER; window: WindowPtr; {CONST}
  301.                                     var initialRLI: PackedRLI; identity: AuthIdentity): OSErr;
  302.     {$IFC NOT GENERATINGCFM}
  303.     inline
  304.         $203C, 9, 101, $AA5D;
  305.     {$ENDC}
  306. {}
  307. {Call this when you're completely done with a panel. It deallocates all of the}
  308. {associated data structures.}
  309. {}
  310.     function SDPDisposePanel (panel: SDPPanelHandle): OSErr;
  311.     {$IFC NOT GENERATINGCFM}
  312.     inline
  313.         $203C, 2, 102, $AA5D;
  314.     {$ENDC}
  315. {}
  316. {If the panel is visible, it makes it invisible by hiding the menu, turning off}
  317. {drawing of the list, and erasing and  invaling the list's rectangle.}
  318. {}
  319.     function SDPHidePanel (panel: SDPPanelHandle): OSErr;
  320.     {$IFC NOT GENERATINGCFM}
  321.     inline
  322.         $203C, 2, 103, $AA5D;
  323.     {$ENDC}
  324. { If the panel is invisible, it makes it visible and draws it. }
  325.     function SDPShowPanel (panel: SDPPanelHandle): OSErr;
  326.     {$IFC NOT GENERATINGCFM}
  327.     inline
  328.         $203C, 2, 104, $AA5D;
  329.     {$ENDC}
  330. { Disables the list and menu so that it won't accept any commands. }
  331.     function SDPEnablePanel (panel: SDPPanelHandle; enable: BOOLEAN): OSErr;
  332.     {$IFC NOT GENERATINGCFM}
  333.     inline
  334.         $203C, 3, 105, $AA5D;
  335.     {$ENDC}
  336. {}
  337. {Move the upper-left-hand corner of the panel to (h,v), given in local coordinates of}
  338. {the panel's window.}
  339. {}
  340.     function SDPMovePanel (panel: SDPPanelHandle; h: INTEGER; v: INTEGER): OSErr;
  341.     {$IFC NOT GENERATINGCFM}
  342.     inline
  343.         $203C, 4, 107, $AA5D;
  344.     {$ENDC}
  345. {}
  346. {Resizes the panel to have the given width and height (keeping the upper-left-hand}
  347. {corner in a fixed position).}
  348. {}
  349.     function SDPSizePanel (panel: SDPPanelHandle; width: INTEGER; height: INTEGER): OSErr;
  350.     {$IFC NOT GENERATINGCFM}
  351.     inline
  352.         $203C, 4, 108, $AA5D;
  353.     {$ENDC}
  354. {}
  355. {This routine simulates a double-click on the selected item (if there is no selected}
  356. {item, then it does nothing), and it returns the result of that "double-click" via the}
  357. {whatHappened parameter. If a container is selected, then that container will be}
  358. {opened and kMovedDownTheHierarchy is returned. If, however, the user is at the lowest}
  359. {level in the hierarchy, then kSDPSelectedAnItem is returned.}
  360. {}
  361.     function SDPOpenSelectedItem (panel: SDPPanelHandle; var whatHappened: SDPPanelState): OSErr;
  362.     {$IFC NOT GENERATINGCFM}
  363.     inline
  364.         $203C, 4, 109, $AA5D;
  365.     {$ENDC}
  366. {}
  367. {Returns whether a record is selected, something else is selected, or nothing is}
  368. {selected.}
  369. {}
  370.     function SDPGetPanelSelectionState (panel: SDPPanelHandle; var itsState: SDPSelectionState): OSErr;
  371.     {$IFC NOT GENERATINGCFM}
  372.     inline
  373.         $203C, 4, 110, $AA5D;
  374.     {$ENDC}
  375. {}
  376. {Returns the size of the currently-selected DSSpec, or zero if a record is}
  377. {not selected.  It is safe to do a NewPtr (SDPGetPanelSelectionSize (...))}
  378. {}
  379.     function SDPGetPanelSelectionSize (panel: SDPPanelHandle; var dsSpecSize: INTEGER): OSErr;
  380.     {$IFC NOT GENERATINGCFM}
  381.     inline
  382.         $203C, 4, 114, $AA5D;
  383.     {$ENDC}
  384. {}
  385. {Returns the currently-selected DSSpec, or a zero-lengthed}
  386. {DSSpec if a record is not selected. It is assumed that the selection}
  387. {buffer allocated is large enough.}
  388. {}
  389.     function SDPGetPanelSelection (panel: SDPPanelHandle; var selection: PackedDSSpec): OSErr;
  390.     {$IFC NOT GENERATINGCFM}
  391.     inline
  392.         $203C, 4, 111, $AA5D;
  393.     {$ENDC}
  394. {}
  395. {Forces browsing to the specified RLI. If prli is the current RLI, then it does}
  396. {nothing.}
  397. {}
  398.     function SDPSetPath (panel: SDPPanelHandle; {CONST}
  399.                                     var prli: PackedRLI): OSErr;
  400.     {$IFC NOT GENERATINGCFM}
  401.     inline
  402.         $203C, 4, 112, $AA5D;
  403.     {$ENDC}
  404. {}
  405. {This is the main driver for the panel.  You should pass all events to SDPPanelEvent}
  406. {including NULL events.  If you have more than 1 panel, you will need to}
  407. {call SDPPanelEvent for each panel.  NOTE:  For Update Events you will also need to call}
  408. {SDPUpdatePanel as described below.}
  409. {}
  410.     function SDPPanelEvent (panel: SDPPanelHandle; {CONST}
  411.                                     var theEvent: EventRecord; var whatHappened: SDPPanelState): OSErr;
  412.     {$IFC NOT GENERATINGCFM}
  413.     inline
  414.         $203C, 6, 113, $AA5D;
  415.     {$ENDC}
  416. {}
  417. {SDPUpdatePanel should be called in response to an update event.  Generally you will}
  418. {have first called BeginUpdate, and pass the windows visRgn as theRgn.  If NULL}
  419. {is passed for theRgn the entire panel is re-drawn.  NOTE:  Drawing is not cliped to}
  420. {theRgn, if this is desired, you must first call SetClip.}
  421. {}
  422.     function SDPUpdatePanel (panel: SDPPanelHandle; theRgn: RgnHandle): OSErr;
  423.     {$IFC NOT GENERATINGCFM}
  424.     inline
  425.         $203C, 4, 106, $AA5D;
  426.     {$ENDC}
  427. {}
  428. {SDPSelectString scrolls and selects the closest matching string at the current}
  429. {level.  This is the same behavior as if the user typed in the given string.}
  430. {}
  431.     function SDPSelectString (panel: SDPPanelHandle; {CONST}
  432.                                     var name: RString): OSErr;
  433.     {$IFC NOT GENERATINGCFM}
  434.     inline
  435.         $203C, 4, 116, $AA5D;
  436.     {$ENDC}
  437. {}
  438. {SDPGetPathLength returns the length in bytes required to hold the current path name}
  439. {in RLI format.  This corresponds to the path name in the popup menu.}
  440. {}
  441.     function SDPGetPathLength (panel: SDPPanelHandle; var pathNameLength: INTEGER): OSErr;
  442.     {$IFC NOT GENERATINGCFM}
  443.     inline
  444.         $203C, 4, 117, $AA5D;
  445.     {$ENDC}
  446. { SDPGetPath returns the current rli. }
  447.     function SDPGetPath (panel: SDPPanelHandle; var prli: PackedRLI; var dsRefNum: INTEGER): OSErr;
  448.     {$IFC NOT GENERATINGCFM}
  449.     inline
  450.         $203C, 6, 118, $AA5D;
  451.     {$ENDC}
  452. {}
  453. {SDPSetFocus will draw the focus rectangle or erase the focus rectangle depending upon}
  454. {the focus boolean.}
  455. {}
  456.     function SDPSetFocus (panel: SDPPanelHandle; focus: BOOLEAN): OSErr;
  457.     {$IFC NOT GENERATINGCFM}
  458.     inline
  459.         $203C, 3, 119, $AA5D;
  460.     {$ENDC}
  461. {}
  462. {SDPSetPanelBalloonHelp allows clients to specify a STR# resource id to use for }
  463. {balloon help.  Balloon help is unavailable until this call is made.}
  464. {}
  465.     function SDPSetPanelBalloonHelp (panel: SDPPanelHandle; balloonHelpID: INTEGER): OSErr;
  466.     {$IFC NOT GENERATINGCFM}
  467.     inline
  468.         $203C, 3, 120, $AA5D;
  469.     {$ENDC}
  470. {}
  471. {SDPInstallPanelBusyProc allows clients to install a CB that will be called while}
  472. {the panel is aynchronously busy.}
  473. {}
  474.     function SDPInstallPanelBusyProc (panel: SDPPanelHandle; busyProc: PanelBusyProc): OSErr;
  475.     {$IFC NOT GENERATINGCFM}
  476.     inline
  477.         $203C, 4, 121, $AA5D;
  478.     {$ENDC}
  479.     function SDPNewFindPanel (var newPanel: SDPFindPanelHandle; window: WindowPtr; upperLeft: Point; layoutResourceID: INTEGER; visible: BOOLEAN; enabled: BOOLEAN; {CONST}
  480.                                     var typesList: RStringPtr; typeCount: LONGINT; matchTypeHow: ByteParameter; identity: AuthIdentity; simultaneousSearchCount: INTEGER; initialFocus: SDPFindPanelFocus; refCon: LONGINT): OSErr;
  481.     {$IFC NOT GENERATINGCFM}
  482.     inline
  483.         $203C, 20, 2300, $AA5D;
  484.     {$ENDC}
  485.     function SDPDisposeFindPanel (findPanel: SDPFindPanelHandle): OSErr;
  486.     {$IFC NOT GENERATINGCFM}
  487.     inline
  488.         $203C, 2, 2301, $AA5D;
  489.     {$ENDC}
  490.     function SDPStartFind (findPanel: SDPFindPanelHandle): OSErr;
  491.     {$IFC NOT GENERATINGCFM}
  492.     inline
  493.         $203C, 2, 2302, $AA5D;
  494.     {$ENDC}
  495.     function SDPStopFind (findPanel: SDPFindPanelHandle): OSErr;
  496.     {$IFC NOT GENERATINGCFM}
  497.     inline
  498.         $203C, 2, 2303, $AA5D;
  499.     {$ENDC}
  500.     function SDPFindPanelEvent (findPanel: SDPFindPanelHandle; {CONST}
  501.                                     var event: EventRecord; var whatHappened: SDPFindPanelResult): OSErr;
  502.     {$IFC NOT GENERATINGCFM}
  503.     inline
  504.         $203C, 6, 2304, $AA5D;
  505.     {$ENDC}
  506.     function SDPUpdateFindPanel (findPanel: SDPFindPanelHandle; theRgn: RgnHandle): OSErr;
  507.     {$IFC NOT GENERATINGCFM}
  508.     inline
  509.         $203C, 4, 2305, $AA5D;
  510.     {$ENDC}
  511.     function SDPShowFindPanel (findPanel: SDPFindPanelHandle): OSErr;
  512.     {$IFC NOT GENERATINGCFM}
  513.     inline
  514.         $203C, 2, 2306, $AA5D;
  515.     {$ENDC}
  516.     function SDPHideFindPanel (findPanel: SDPFindPanelHandle): OSErr;
  517.     {$IFC NOT GENERATINGCFM}
  518.     inline
  519.         $203C, 2, 2307, $AA5D;
  520.     {$ENDC}
  521.     function SDPMoveFindPanel (findPanel: SDPFindPanelHandle; h: INTEGER; v: INTEGER): OSErr;
  522.     {$IFC NOT GENERATINGCFM}
  523.     inline
  524.         $203C, 4, 2308, $AA5D;
  525.     {$ENDC}
  526.     function SDPEnableFindPanel (findPanel: SDPFindPanelHandle; enabled: BOOLEAN): OSErr;
  527.     {$IFC NOT GENERATINGCFM}
  528.     inline
  529.         $203C, 3, 2309, $AA5D;
  530.     {$ENDC}
  531.     function SDPSetFindPanelFocus (findPanel: SDPFindPanelHandle; newFocus: SDPFindPanelFocus): OSErr;
  532.     {$IFC NOT GENERATINGCFM}
  533.     inline
  534.         $203C, 3, 2310, $AA5D;
  535.     {$ENDC}
  536.     function SDPGetFindPanelState (findPanel: SDPFindPanelHandle; var itsState: SDPFindPanelState): OSErr;
  537.     {$IFC NOT GENERATINGCFM}
  538.     inline
  539.         $203C, 4, 2311, $AA5D;
  540.     {$ENDC}
  541.     function SDPGetFindPanelSelectionSize (findPanel: SDPFindPanelHandle; var size: INTEGER): OSErr;
  542.     {$IFC NOT GENERATINGCFM}
  543.     inline
  544.         $203C, 4, 2312, $AA5D;
  545.     {$ENDC}
  546.     function SDPGetFindPanelSelection (findPanel: SDPFindPanelHandle; var selection: PackedDSSpec): OSErr;
  547.     {$IFC NOT GENERATINGCFM}
  548.     inline
  549.         $203C, 4, 2313, $AA5D;
  550.     {$ENDC}
  551.     function SDPSetFindPanelBalloonHelp (findPanel: SDPFindPanelHandle; balloonHelpID: INTEGER): OSErr;
  552.     {$IFC NOT GENERATINGCFM}
  553.     inline
  554.         $203C, 3, 2314, $AA5D;
  555.     {$ENDC}
  556.     function SDPSetFindIdentity (findPanel: SDPFindPanelHandle; identity: AuthIdentity): OSErr;
  557.     {$IFC NOT GENERATINGCFM}
  558.     inline
  559.         $203C, 4, 2315, $AA5D;
  560.     {$ENDC}
  561.     function SDPInstallFindPanelBusyProc (findPanel: SDPFindPanelHandle; busyProc: FindPanelBusyProc): OSErr;
  562.     {$IFC NOT GENERATINGCFM}
  563.     inline
  564.         $203C, 4, 2316, $AA5D;
  565.     {$ENDC}
  566.     function SDPGetIconByType ({CONST}
  567.                                     var recordType: RString; whichIcons: IconSelectorValue; var iconSuite: Handle): OSErr;
  568.     {$IFC NOT GENERATINGCFM}
  569.     inline
  570.         $303C, 1024, $AA5C;
  571.     {$ENDC}
  572.     function SDPGetDSSpecIcon ({CONST}
  573.                                     var packed_DSSpec: PackedDSSpec; whichIcons: IconSelectorValue; var iconSuite: Handle): OSErr;
  574.     {$IFC NOT GENERATINGCFM}
  575.     inline
  576.         $303C, 1025, $AA5C;
  577.     {$ENDC}
  578.     function SDPGetCategories (var categories: PackedRStringListHandle; var displayNames: PackedRStringListHandle): OSErr;
  579.     {$IFC NOT GENERATINGCFM}
  580.     inline
  581.         $303C, 1026, $AA5C;
  582.     {$ENDC}
  583.     function SDPGetCategoryTypes ({CONST}
  584.                                     var category: RString; var types: PackedRStringListHandle): OSErr;
  585.     {$IFC NOT GENERATINGCFM}
  586.     inline
  587.         $303C, 1027, $AA5C;
  588.     {$ENDC}
  589.     function SDPResolveAliasFile (fileSpec: FSSpecPtr; resolvedDSSpec: PackedDSSpecHandle; identity: AuthIdentity; mayPromptUser: BOOLEAN): OSErr;
  590.     {$IFC NOT GENERATINGCFM}
  591.     inline
  592.         $203C, 7, 3700, $AA5D;
  593.     {$ENDC}
  594.     function SDPResolveAliasDSSpec (theAliasDSSpec: PackedDSSpecHandle; identity: AuthIdentity; mayPromptUser: BOOLEAN): OSErr;
  595.     {$IFC NOT GENERATINGCFM}
  596.     inline
  597.         $203C, 5, 3701, $AA5D;
  598.     {$ENDC}
  599.     function SDPRepairPersonalDirectory (var pd: FSSpec; showProgress: BOOLEAN): OSErr;
  600.     {$IFC NOT GENERATINGCFM}
  601.     inline
  602.         $203C, 3, 6700, $AA5D;
  603.     {$ENDC}
  604.  
  605. { $ALIGN RESET}
  606. { $POP}
  607.  
  608. {$ENDC}
  609.  {__OCESTANDARDDIRECTORY__}
  610.  
  611. implementation
  612. end.
  613.